{
 "cells": [
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-11T15:46:46.185673Z",
     "start_time": "2024-10-11T15:46:42.572706Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.datasets import load_iris\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# 数据获取\n",
    "def get_data():\n",
    "    iris = load_iris()\n",
    "    data = iris.data\n",
    "    result = iris.target\n",
    "    return data, result\n",
    "\n",
    "# 将数据处理为训练集和测试集\n",
    "def data_deal(data, result):\n",
    "    data_list = []\n",
    "    for i in data:\n",
    "        tem_list = [i[0], i[1]]\n",
    "        data_list.append(tem_list)\n",
    "    res_list = []\n",
    "    for j in result:\n",
    "        res_list.append(j)\n",
    "    train_list = data_list[0: 10] + data_list[20: 80] + data_list[90: 100]\n",
    "    train_result = res_list[0: 10] + res_list[20: 80] + res_list[90: 100]\n",
    "    test_list = data_list[0: 40] + data_list[60: 100]\n",
    "    test_result = res_list[0: 40] + res_list[60: 100]\n",
    "\n",
    "    return data_list, train_list, test_list, train_result, test_result\n",
    "\n",
    "# 回归方法训练\n",
    "def train(learning_rate, iter_num, train_data, result):\n",
    "    x_c = 0\n",
    "    y_c = 0\n",
    "    for i in train_data:\n",
    "        x_c = x_c + i[0]\n",
    "        y_c = y_c + i[1]\n",
    "    m = x_c/len(train_data)\n",
    "    n = y_c/len(train_data)\n",
    "    w = 0\n",
    "    b = 0\n",
    "    ok_rate = 0\n",
    "    for i in range(iter_num):\n",
    "        train_r = []\n",
    "        b = n-w*m\n",
    "        count = 0\n",
    "        for j in train_data:\n",
    "            if j[1] > w*j[0]+b:\n",
    "                train_r.append(0)\n",
    "            else:\n",
    "                train_r.append(1)\n",
    "        for ii in range(len(result)):\n",
    "            if result[ii] == train_r[ii]:\n",
    "                count = count+1\n",
    "        train_ok_rate = count/len(train_data)\n",
    "        if ok_rate <= train_ok_rate:\n",
    "            w = w + learning_rate\n",
    "        else:\n",
    "            w = w - learning_rate\n",
    "        learning_rate = learning_rate*0.9\n",
    "        ok_rate = train_ok_rate\n",
    "\n",
    "    return ok_rate, w, b\n",
    "\n",
    "\n",
    "# 回归方法测试\n",
    "def test(w, b, test_list, test_result):\n",
    "    test_res = []\n",
    "    count = 0\n",
    "    for j in test_list:\n",
    "        if j[1] > w * j[0] + b:\n",
    "            test_res.append(0)\n",
    "        else:\n",
    "            test_res.append(1)\n",
    "    for i in range(len(test_result)):\n",
    "        if result[i] == test_res[i]:\n",
    "            count = count + 1\n",
    "    oks = count/len(test_result)\n",
    "    return oks\n",
    "\n",
    "\n",
    "# 绘制函数图像和输入点\n",
    "def fun_image(w, b, dot):\n",
    "    iris = load_iris()\n",
    "    irisFeature = iris.data\n",
    "    irisTarget = iris.target\n",
    "\n",
    "    ax1 = plt.subplot(1, 2, 1)\n",
    "    ax2 = plt.subplot(1, 2, 2)\n",
    "\n",
    "    plt.sca(ax1)\n",
    "    for i in range(0, 100):\n",
    "        if irisTarget[i] == 0:\n",
    "            type11 = plt.scatter(irisFeature[i, 0], irisFeature[i, 1], c=\"r\")\n",
    "        elif irisTarget[i] == 1:\n",
    "            type22 = plt.scatter(irisFeature[i, 0], irisFeature[i, 1], c=\"g\")\n",
    "\n",
    "    plt.title(\"show train and test\")\n",
    "    plt.xlabel(\"ewidth\")\n",
    "    plt.ylabel(\"elength\")\n",
    "    x = np.linspace(4, 7, 256)\n",
    "    plt.plot(x, w * x + b, color='black')\n",
    "    plt.legend((type11, type22), ('0', '1'))\n",
    "    plt.plot(dot[0], dot[1], color='black', marker='+')\n",
    "\n",
    "    plt.sca(ax2)\n",
    "    for i in range(20, 80):\n",
    "        if irisTarget[i] == 0:\n",
    "            type1 = plt.scatter(irisFeature[i, 0], irisFeature[i, 1], c=\"r\", marker=\"8\")\n",
    "        elif irisTarget[i] == 1:\n",
    "            type2 = plt.scatter(irisFeature[i, 0], irisFeature[i, 1], c=\"g\", marker=\"8\")\n",
    "    for i in range(0, 20):\n",
    "        if irisTarget[i] == 0:\n",
    "            type3 = plt.scatter(irisFeature[i, 0], irisFeature[i, 1], c=\"blue\", marker=\"v\")\n",
    "        elif irisTarget[i] == 1:\n",
    "            plt.scatter(irisFeature[i, 0], irisFeature[i, 1], c=\"orange\", marker=\"v\")\n",
    "    for i in range(80, 100):\n",
    "        if irisTarget[i] == 0:\n",
    "            plt.scatter(irisFeature[i, 0], irisFeature[i, 1], c=\"blue\", marker=\"v\")\n",
    "        elif irisTarget[i] == 1:\n",
    "            type4 = plt.scatter(irisFeature[i, 0], irisFeature[i, 1], c=\"orange\", marker=\"v\")\n",
    "\n",
    "\n",
    "    plt.title(\"show all\")\n",
    "    plt.xlabel(\"ewidth\")\n",
    "    plt.ylabel(\"elength\")\n",
    "    x = np.linspace(4, 7, 256)\n",
    "    plt.plot(x, w*x+b, color='black')\n",
    "    plt.plot(dot[0], dot[1], color='black', marker='+')\n",
    "\n",
    "    plt.legend((type1, type2, type3, type4), ('train-0', 'train-1', 'test-0', 'test-1'))\n",
    "    plt.show()\n",
    "\n",
    "# 回归方法判断点的类型\n",
    "def check_point(w, b, dot):\n",
    "    y = w*dot[0] + b\n",
    "    if y > dot[1]:\n",
    "        return \"回归判断该点类别为0\"\n",
    "    else:\n",
    "        return \"回归判断该点类别为1\"\n",
    "\n",
    "\n",
    "# k近邻法计算距离方法\n",
    "def distance(A, B):\n",
    "    return (abs((B[0]-A[0])**2+(B[1]-A[1])**2))**0.5\n",
    "\n",
    "\n",
    "# k近邻法训练，测试准确率\n",
    "def K_train(train_list, train_result, k):\n",
    "    dis_list = []\n",
    "    # 所有点到别的点的距离\n",
    "    for i in train_list:\n",
    "        dis = []\n",
    "        for j in train_list:\n",
    "            dis.append(distance(i, j))\n",
    "        dis_list.append(dis)\n",
    "\n",
    "    # 获取到训练集中每个点的最近5个点的索引\n",
    "    min_dis_list = []\n",
    "    for m in range(len(dis_list)):\n",
    "        temp = []\n",
    "        for n in range(int(k+1)):\n",
    "            temp.append(dis_list[m].index(min(dis_list[m])))\n",
    "            dis_list[m][dis_list[m].index(min(dis_list[m]))] = 100\n",
    "            temp.sort()\n",
    "        x = temp[1:]\n",
    "        min_dis_list.append(x)\n",
    "\n",
    "    # 根据索引判断对应点的类别\n",
    "    dot_type = []\n",
    "    for ii in min_dis_list:\n",
    "        mm = 0\n",
    "        nn = 0\n",
    "        for jj in ii:\n",
    "            if jj <= 50:\n",
    "                mm = mm+1\n",
    "            else:\n",
    "                nn = nn+1\n",
    "        if mm >= nn:\n",
    "            dot_type.append(0)\n",
    "        else:\n",
    "            dot_type.append(1)\n",
    "\n",
    "    # 计算准确率\n",
    "    count = 0\n",
    "    for xx in range(len(dot_type)):\n",
    "        if dot_type[xx] == train_result[xx]:\n",
    "            count = count+1\n",
    "\n",
    "    return count/len(dot_type)\n",
    "\n",
    "\n",
    "# k近邻法判断点的类型\n",
    "def K_check_point(dots, check_list, result):\n",
    "    dis = []\n",
    "    for i in check_list:\n",
    "        dis.append(distance(dots, i))\n",
    "    min_dis = []\n",
    "    for j in range(5):\n",
    "        min_dis.append(dis.index(min(dis)))\n",
    "        dis[dis.index(min(dis))] = 100\n",
    "    zero = 0\n",
    "    one = 0\n",
    "    for s in min_dis:\n",
    "        if result[s] == 0:\n",
    "            zero = zero+1\n",
    "        else:\n",
    "            one = one+1\n",
    "    if one > zero:\n",
    "        return \"K近邻法判断该点类别为0\"\n",
    "    else:\n",
    "        return \"K近邻法判断该点类别为1\"\n",
    "\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    data, result = get_data()\n",
    "    data_list, train_list, test_list, train_result, test_result = data_deal(data, result)\n",
    "    learning_rate = 1\n",
    "    iter_num = 1000\n",
    "    ok_rate, w, b = train(learning_rate, iter_num, train_list, train_result)\n",
    "    test_ok_rate = test(w, b, test_list, test_result)\n",
    "    k = 5\n",
    "    K_ok_rate = K_train(train_list, train_result, k)\n",
    "  \n",
    "    print(\"回归方法\"\n",
    "          \"数学模型:y={}x+{}\\n\"\n",
    "          \"learning_rate:{}\\titer_num:{}\\n\"\n",
    "          \"训练模型准确率:{}\\n\"\n",
    "          \"测试模型准确率:{}\\n\".format(round(w, 3), round(b, 3), learning_rate, iter_num, ok_rate, test_ok_rate))\n",
    "    print(\"K近邻法\\n\"\n",
    "          \"K值选取为{}\\n\"\n",
    "          \"判断准确率为{}\\n\".format(k, K_ok_rate))\n",
    "\n",
    "    dots = list(map(float, input(\"请输入要判断的点：\").split()))\n",
    "    fun_image(w, b, dots)\n",
    "    print(check_point(w, b, dots))\n",
    "    print(K_check_point(dots, train_list, train_result))\n",
    "\n"
   ],
   "id": "c4d6f988ea7cfd63",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "回归方法数学模型:y=1.671x+-6.047\n",
      "learning_rate:1\titer_num:1000\n",
      "训练模型准确率:0.9625\n",
      "测试模型准确率:0.85\n",
      "\n",
      "K近邻法\n",
      "K值选取为5\n",
      "判断准确率为0.9625\n",
      "\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[1;31mIndexError\u001B[0m                                Traceback (most recent call last)",
      "Cell \u001B[1;32mIn[66], line 233\u001B[0m\n\u001B[0;32m    228\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mK近邻法\u001B[39m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m    229\u001B[0m       \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mK值选取为\u001B[39m\u001B[38;5;132;01m{}\u001B[39;00m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m    230\u001B[0m       \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m判断准确率为\u001B[39m\u001B[38;5;132;01m{}\u001B[39;00m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;241m.\u001B[39mformat(k, K_ok_rate))\n\u001B[0;32m    232\u001B[0m dots \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mlist\u001B[39m(\u001B[38;5;28mmap\u001B[39m(\u001B[38;5;28mfloat\u001B[39m, \u001B[38;5;28minput\u001B[39m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m请输入要判断的点：\u001B[39m\u001B[38;5;124m\"\u001B[39m)\u001B[38;5;241m.\u001B[39msplit()))\n\u001B[1;32m--> 233\u001B[0m \u001B[43mfun_image\u001B[49m\u001B[43m(\u001B[49m\u001B[43mw\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mb\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mdots\u001B[49m\u001B[43m)\u001B[49m\n\u001B[0;32m    234\u001B[0m \u001B[38;5;28mprint\u001B[39m(check_point(w, b, dots))\n\u001B[0;32m    235\u001B[0m \u001B[38;5;28mprint\u001B[39m(K_check_point(dots, train_list, train_result))\n",
      "Cell \u001B[1;32mIn[66], line 101\u001B[0m, in \u001B[0;36mfun_image\u001B[1;34m(w, b, dot)\u001B[0m\n\u001B[0;32m     99\u001B[0m plt\u001B[38;5;241m.\u001B[39mplot(x, w \u001B[38;5;241m*\u001B[39m x \u001B[38;5;241m+\u001B[39m b, color\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mblack\u001B[39m\u001B[38;5;124m'\u001B[39m)\n\u001B[0;32m    100\u001B[0m plt\u001B[38;5;241m.\u001B[39mlegend((type11, type22), (\u001B[38;5;124m'\u001B[39m\u001B[38;5;124m0\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124m1\u001B[39m\u001B[38;5;124m'\u001B[39m))\n\u001B[1;32m--> 101\u001B[0m plt\u001B[38;5;241m.\u001B[39mplot(dot[\u001B[38;5;241m0\u001B[39m], \u001B[43mdot\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;241;43m1\u001B[39;49m\u001B[43m]\u001B[49m, color\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mblack\u001B[39m\u001B[38;5;124m'\u001B[39m, marker\u001B[38;5;241m=\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124m+\u001B[39m\u001B[38;5;124m'\u001B[39m)\n\u001B[0;32m    103\u001B[0m plt\u001B[38;5;241m.\u001B[39msca(ax2)\n\u001B[0;32m    104\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m i \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mrange\u001B[39m(\u001B[38;5;241m20\u001B[39m, \u001B[38;5;241m80\u001B[39m):\n",
      "\u001B[1;31mIndexError\u001B[0m: list index out of range"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 66
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
